home *** CD-ROM | disk | FTP | other *** search
/ Chip: 2001 Haziran / CHIP Haziran2001.iso / prog / haziran / 19 / setup.exe / data.z / altera_diag.c < prev    next >
C/C++ Source or Header  |  2001-04-11  |  10KB  |  296 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - altera_diag.c
  3. //
  4. // This is a diagnostics application for accessing the ALTERA card.
  5. // Code was generated by Driver Wizard.
  6. // It accesses the hardware via WinDriver functions.
  7. // 
  8. ////////////////////////////////////////////////////////////////
  9.  
  10. #include "../lib/altera_lib.h"
  11. #include "../../../samples/shared/pci_diag_lib.h"
  12. #include <stdio.h>
  13.  
  14. // input of command from user
  15. static char line[256];
  16.  
  17. char *ALTERA_GetAddrSpaceName(ALTERA_ADDR addrSpace)
  18. {
  19.     return 
  20.         addrSpace==ALTERA_AD_BAR0 ? "Addr Space BAR0" :
  21.         addrSpace==ALTERA_AD_BAR1 ? "Addr Space BAR1" :
  22.         addrSpace==ALTERA_AD_BAR2 ? "Addr Space BAR2" :
  23.         addrSpace==ALTERA_AD_BAR3 ? "Addr Space BAR3" :
  24.         addrSpace==ALTERA_AD_BAR4 ? "Addr Space BAR4" :
  25.         addrSpace==ALTERA_AD_BAR5 ? "Addr Space BAR5" :
  26.         addrSpace==ALTERA_AD_EPROM ? "EEPROM Addr Space" :
  27.         "Invalid";
  28. }
  29.  
  30. void ALTERA_AccessRanges(ALTERA_HANDLE hALTERA)
  31. {
  32.     int cmd, cmd2, i;
  33.     DWORD addr, data;
  34.     ALTERA_ADDR ad_sp = 0;
  35.     ALTERA_MODE ad_mode = ALTERA_MODE_DWORD;
  36.  
  37.     for (; ad_sp<ALTERA_ITEMS && !ALTERA_IsAddrSpaceActive(hALTERA, ad_sp); ad_sp++)
  38.     if (ad_sp==ALTERA_ITEMS)
  39.     {
  40.         printf ("No active memory or IO ranges on board!\n");
  41.         return;
  42.     }
  43.  
  44.     do
  45.     {
  46.         printf ("Access the board's memory and IO ranges\n");
  47.         printf ("---------------------------------------\n");
  48.         printf ("1. Change active memory space: %s\n",ALTERA_GetAddrSpaceName(ad_sp));
  49.         printf ("2. Toggle active mode: %s\n", 
  50.             ad_mode==ALTERA_MODE_BYTE ? "BYTE (8 bit)" :
  51.             ad_mode==ALTERA_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  52.         printf ("3. Read from board\n");
  53.         printf ("4. Write to board\n");
  54.         printf ("99. Back to main menu\n");
  55.         printf ("\n");
  56.         printf ("Enter option: ");
  57.         cmd = 0;
  58.         fgets(line, sizeof(line), stdin);
  59.         sscanf(line, "%d",&cmd);
  60.         switch (cmd)
  61.         {
  62.         case 1:
  63.             printf ("Choose memory or IO space:\n");
  64.             printf ("--------------------------\n");
  65.             for (i=0; i<ALTERA_ITEMS; i++)
  66.             {
  67.                 printf ("%d. %s", i+1, ALTERA_GetAddrSpaceName(i));
  68.                 if (!ALTERA_IsAddrSpaceActive(hALTERA, (ALTERA_ADDR) i))
  69.                     printf (" - space not active");
  70.                 printf("\n");
  71.             }
  72.             printf ("Enter option: ");
  73.             cmd2 = 99;
  74.             fgets(line, sizeof(line), stdin);
  75.             sscanf(line, "%d",&cmd2);
  76.             if (cmd2>=1 && cmd2<ALTERA_ITEMS+1)
  77.             {
  78.                 ad_sp = cmd2-1;
  79.                 if (!ALTERA_IsAddrSpaceActive(hALTERA, ad_sp))
  80.                     printf ("Chosen space not active!\n");
  81.             }
  82.             break;
  83.         case 2:
  84.             ad_mode = (ad_mode + 1) % 3;
  85.             break;
  86.         case 3:
  87.             printf ("Enter offset to read from: ");
  88.             fgets(line, sizeof(line), stdin);
  89.             sscanf (line, "%x", &addr);
  90.             switch (ad_mode)
  91.             {
  92.             case ALTERA_MODE_BYTE:
  93.                 data = ALTERA_ReadByte(hALTERA, ad_sp, addr);
  94.                 break;
  95.             case ALTERA_MODE_WORD:
  96.                 data = ALTERA_ReadWord(hALTERA, ad_sp, addr);
  97.                 break;
  98.             case ALTERA_MODE_DWORD:
  99.                 data = ALTERA_ReadDword(hALTERA, ad_sp, addr);
  100.                 break;
  101.             }
  102.             printf ("Value read: %x\n", data);
  103.             break;
  104.         case 4:
  105.             printf ("Enter offset to write to: ");
  106.             fgets(line, sizeof(line), stdin);
  107.             sscanf (line,"%x", &addr);
  108.             printf ("Enter data to write %s: ",
  109.                 ad_mode==ALTERA_MODE_BYTE ? "BYTE (8 bit)" :
  110.                 ad_mode==ALTERA_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  111.             fgets(line, sizeof(line), stdin);
  112.             sscanf (line, "%x",&data);
  113.             switch (ad_mode)
  114.             {
  115.             case ALTERA_MODE_BYTE:
  116.                 ALTERA_WriteByte(hALTERA, ad_sp, addr, (BYTE) data);
  117.                 break;
  118.             case ALTERA_MODE_WORD:
  119.                 ALTERA_WriteWord(hALTERA, ad_sp, addr, (WORD) data);
  120.                 break;
  121.             case ALTERA_MODE_DWORD:
  122.                 ALTERA_WriteDword(hALTERA, ad_sp, addr, data);
  123.                 break;
  124.             }
  125.             break;
  126.         }
  127.     } while (cmd!=99);
  128. }
  129.  
  130. void WINAPI ALTERA_IntHandlerRoutine(ALTERA_HANDLE hALTERA, ALTERA_INT_RESULT *intResult)
  131. {
  132.     printf ("Got Int number %d\n", intResult->dwCounter);
  133. }
  134.  
  135. void ALTERA_EnableDisableInterrupts(ALTERA_HANDLE hALTERA)
  136. {
  137.     int cmd;
  138.  
  139.     printf ("WARNING!!!\n");
  140.     printf ("----------\n");
  141.     printf ("Your hardware has level sensitive interrupts.\n");
  142.     printf ("You must modify the source code of ALTERA_IntEnable(), in the file altera_lib.c,\n");
  143.     printf ("to acknowledge the interrupt before enabling interrupts.\n");
  144.     printf ("Without this modification, your PC will HANG upon interrupt!\n");
  145.     printf ("\n");
  146.  
  147.     do
  148.     {
  149.         printf ("Enable / Disable interrupts\n");
  150.         printf ("---------------------------\n");
  151.         printf ("1. %s Int\n", ALTERA_IntIsEnabled(hALTERA) ? "Disable" : "Enable");
  152.         printf ("99. Back to main menu\n");
  153.         printf ("\n");
  154.         printf ("Enter option: ");
  155.         cmd = 0;
  156.         fgets(line, sizeof(line), stdin);
  157.         sscanf(line, "%d",&cmd);
  158.         switch (cmd)
  159.         {
  160.         case 1:
  161.             if (ALTERA_IntIsEnabled(hALTERA))
  162.             {
  163.                 printf ("Disabling interrupt Int\n");
  164.                 ALTERA_IntDisable(hALTERA);
  165.             }
  166.             else
  167.             {
  168.                 printf ("Enabling interrupt Int\n");
  169.                 if (!ALTERA_IntEnable(hALTERA, ALTERA_IntHandlerRoutine))
  170.                     printf ("failed enabling interrupt Int\n");
  171.             }
  172.             break;
  173.         }
  174.     } while (cmd!=99);
  175. }
  176.  
  177. ALTERA_HANDLE ALTERA_LocateAndOpenBoard (DWORD dwVendorID, DWORD dwDeviceID, BOOL fUseInt)
  178. {
  179.     DWORD cards, my_card;
  180.     ALTERA_HANDLE hALTERA = NULL;
  181.  
  182.     if (dwVendorID==0)
  183.     {
  184.         printf ("Enter VendorID: ");
  185.         fgets(line, sizeof(line), stdin);
  186.         sscanf (line, "%x",&dwVendorID);
  187.         if (dwVendorID==0) return NULL;
  188.  
  189.         printf ("Enter DeviceID: ");
  190.         fgets(line, sizeof(line), stdin);
  191.         sscanf (line, "%x",&dwDeviceID);
  192.     }
  193.     cards = ALTERA_CountCards (dwVendorID, dwDeviceID);
  194.     if (cards==0)
  195.     {
  196.         printf("%s", ALTERA_ErrorString);
  197.         return NULL;
  198.     }
  199.     else if (cards==1) my_card = 1;
  200.     else
  201.     {
  202.         DWORD i;
  203.  
  204.         printf("Found %d matching PCI cards\n", cards);
  205.         printf("Select card (1-%d): ", cards);
  206.         i = 0;
  207.         fgets(line, sizeof(line), stdin);
  208.         sscanf (line, "%d",&i);
  209.         if (i>=1 && i <=cards) my_card = i;
  210.         else 
  211.         {
  212.             printf ("Choice out of range\n");
  213.             return NULL;
  214.         }
  215.     }
  216.     if (ALTERA_Open (&hALTERA, dwVendorID, dwDeviceID, my_card - 1, fUseInt ? ALTERA_OPEN_USE_INT : 0 ))
  217.         printf ("ALTERA PCI card found!\n");
  218.     else printf ("%s", ALTERA_ErrorString);
  219.     return hALTERA;
  220. }
  221.  
  222. int main(int argc, char *argv[])
  223. {
  224.     int cmd;
  225.     ALTERA_HANDLE hALTERA = NULL;
  226.     HANDLE hWD;
  227.     BOOL fUseInt = FALSE; // by default - do not install interrupts
  228.     BOOL fOpenedWithInt = fUseInt;
  229.  
  230.     printf ("ALTERA diagnostic utility.\n");
  231.     printf ("Application accesses hardware using " WD_PROD_NAME ".\n");
  232.  
  233.     // make sure WinDriver is loaded
  234.     if (!PCI_Get_WD_handle(&hWD)) return 0;
  235.     WD_Close (hWD);
  236.  
  237.     if (ALTERA_DEFAULT_VENDOR_ID)
  238.         hALTERA = ALTERA_LocateAndOpenBoard(ALTERA_DEFAULT_VENDOR_ID, ALTERA_DEFAULT_DEVICE_ID, fUseInt);
  239.  
  240.     do
  241.     {
  242.         printf ("\n");
  243.         printf ("ALTERA main menu\n");
  244.         printf ("-------------------\n");
  245.         printf ("1. Scan PCI bus\n");
  246.         printf ("2. Set opening board %s interrupts\n", fUseInt ? "without" : "with");
  247.         printf ("3. Locate/Choose ALTERA board (%s interrupts)\n", fUseInt ? "with" : "without");
  248.         if (hALTERA)
  249.         {
  250.             printf ("4. PCI configuration registers\n");
  251.             printf ("6. Access ALTERA memory and IO ranges\n");
  252.             if (fOpenedWithInt)
  253.                 printf ("7. Enable / Disable interrupts\n");
  254.         }
  255.         printf ("99. Exit\n");
  256.         printf ("Enter option: ");
  257.         cmd = 0;
  258.         fgets(line, sizeof(line), stdin);
  259.         sscanf(line, "%d",&cmd);
  260.         switch (cmd)
  261.         {
  262.         case 1: // Scan PCI bus
  263.             PCI_Print_all_cards_info();
  264.             break;
  265.         case 2: // Set opening board with / without interrupts
  266.             fUseInt = !fUseInt;
  267.             break;
  268.         case 3: // Locate ALTERA board
  269.             if (hALTERA) ALTERA_Close(hALTERA);
  270.             hALTERA = ALTERA_LocateAndOpenBoard(0, 0, fUseInt);
  271.             if (!hALTERA) printf ("ALTERA card open failed!\n");
  272.             fOpenedWithInt = fUseInt;
  273.             break;
  274.         case 4: // PCI configuration registers
  275.             if (hALTERA)
  276.             {
  277.                 WD_PCI_SLOT pciSlot;
  278.                 ALTERA_GetPciSlot(hALTERA, &pciSlot);
  279.                 PCI_EditConfigReg(pciSlot);
  280.                 break;
  281.             }
  282.         case 6: // Access ALTERA memory and IO ranges
  283.             if (hALTERA) ALTERA_AccessRanges(hALTERA);
  284.             break;
  285.         case 7: // Enable / Disable interrupts
  286.             if (hALTERA && fOpenedWithInt)
  287.                 ALTERA_EnableDisableInterrupts(hALTERA);
  288.             break;
  289.         }
  290.     } while (cmd!=99);
  291.  
  292.     if (hALTERA) ALTERA_Close(hALTERA);
  293.  
  294.     return 0;
  295. }
  296.